package com.malou.client.seguridad.usuario;

import java.util.List;

import com.extjs.gxt.ui.client.data.BaseListLoader;
import com.extjs.gxt.ui.client.data.BaseTreeLoader;
import com.extjs.gxt.ui.client.data.BeanModel;
import com.extjs.gxt.ui.client.data.BeanModelReader;
import com.extjs.gxt.ui.client.data.ListLoadResult;
import com.extjs.gxt.ui.client.data.ListLoader;
import com.extjs.gxt.ui.client.data.LoadEvent;
import com.extjs.gxt.ui.client.data.ModelData;
import com.extjs.gxt.ui.client.data.RpcProxy;
import com.extjs.gxt.ui.client.data.TreeLoader;
import com.extjs.gxt.ui.client.data.TreeModelReader;
import com.extjs.gxt.ui.client.event.LoadListener;
import com.extjs.gxt.ui.client.store.ListStore;
import com.extjs.gxt.ui.client.store.TreeStore;
import com.extjs.gxt.ui.client.widget.MessageBox;
import com.google.gwt.core.client.GWT;
import com.google.gwt.user.client.Window;
import com.google.gwt.user.client.rpc.AsyncCallback;
import com.malou.client.Malou;
import com.malou.client.MalouConstants;
import com.malou.client.seguridad.login.LoginDialog;
import com.malou.client.seguridad.login.LoginService;
import com.malou.client.seguridad.login.LoginServiceAsync;
import com.malou.client.util.MensajeData;
import com.malou.client.util.Utilities;

public class Usuarios{
	private static UsuarioServiceAsync us = GWT.create(UsuarioService.class);
	private static LoginServiceAsync ls = GWT.create(LoginService.class);
	public static TreeLoader<Usuario> loader;
	public static TreeStore<Usuario> store;
	public static GrupoDialog grupoDialog;
	public static UsuarioDialog usuarioDialog;
	public static RolesDialog rolesDialog;
	public static Integer user_id;
	
	public static ListLoader<ListLoadResult<Rol>> loaderListView;
	public static ListStore<BeanModel> storeListView;
	public static ListStore<BeanModel> storePrivilegio;
	public static ListLoader<ListLoadResult<ModelData>> loaderPrivilegio;
	
	private static MalouConstants constants = GWT.create(MalouConstants.class);
	
	public static Malou malou;
	public static LoginDialog dialog;
	
	public static void list(){
		RpcProxy<Usuario> proxy = new RpcProxy<Usuario>() {        
			@Override
	        public void load(Object loadConfig, AsyncCallback<Usuario> callback) {
	          us.getUsuario((Usuario) loadConfig,callback);				
	        }
	      };    
	    
	    TreeModelReader<List<Usuario>> reader = new TreeModelReader<List<Usuario>>();
	    
	    
	      loader = new BaseTreeLoader<Usuario>(proxy,reader){
	    	  @Override
	    	  public boolean hasChildren(Usuario parent) {
	    		  
	    	    return parent.get("haschildren") != null || parent.get("hasusers") != null;
	    	  }
	      };	    
	    
	    store = new TreeStore<Usuario>(loader);
	    /*
	    store.setKeyProvider(new ModelKeyProvider<Usuario>() {  
	      public String getKey(Usuario model) {  
	         return "user_" + model.get("id");  
	      }  
	    });*/ 
	}
	
	public static void saveGroup(Usuario user) {
		user_id = user.getId();
		
		
		us.saveGroup(user, new AsyncCallback<MensajeData>() {

			@Override
			public void onFailure(Throwable caught) {				
				MessageBox.alert(constants.sistemaMarcocruzado(), constants.errorConexion(), null);	
				store.rejectChanges();
			}

			@Override
			public void onSuccess(MensajeData data) {
				if (data.guardado) {					
					grupoDialog.hide();
					if(user_id != null){
						store.commitChanges();
					}else{						 
						loader.load();
					}
					
				}
				 else {
					 grupoDialog.status.hide();
					 grupoDialog.getButtonBar().enable();	
					 String msg;					
					 if(data.errorTipo == 1)
						 msg = constants.usuarioYaExisteRol();
					 else
						 msg = constants.usuarioNoGuardadoGrupo();
					 MessageBox.alert(constants.sistemaMarcocruzado(), msg, null);
				}						
			}
			
		});
	}
	
	public static void deleteGroup(Integer id) {
		  
		  us.deleteGroup(id, new AsyncCallback<MensajeData>() {

				@Override
				public void onFailure(Throwable caught) {					
					MessageBox.alert(constants.sistemaMarcocruzado(), constants.errorConexion(), null);					
				}

				@Override
				public void onSuccess(MensajeData data) {
					if (data.guardado) {												
						loader.load();						
					}
					 else {						 					 
						 MessageBox.alert(constants.sistemaMarcocruzado(), constants.usuarioNoEliminadoGrupo(), null);
					}						
				}
				
			});
	}
	
	public static void saveUser(Usuario user) {
		user_id = user.getId();		
		
		us.saveUser(user, new AsyncCallback<MensajeData>() {

			@Override
			public void onFailure(Throwable caught) {				
				MessageBox.alert(constants.sistemaMarcocruzado(), constants.errorConexion(), null);	
				store.rejectChanges();
			}

			@Override
			public void onSuccess(MensajeData data) {
				if (data.guardado) {					
					usuarioDialog.hide();
					if(user_id != null){
						store.commitChanges();
					}else{						 
						loader.load();
					}
					
				}
				 else {					 
					 usuarioDialog.status.hide();
					 usuarioDialog.getButtonBar().enable();
					 String msg;
					 if(data.errorTipo == 1)
						 msg = constants.usuarioYaExiste();
					 else
						 msg = constants.usuarioNoGuardadoUsuario();
					 MessageBox.alert(constants.sistemaMarcocruzado(), msg, null);
				}						
			}
			
		});
	}
	
	public static void deleteUser(Integer id, Integer rol_id) {
		  
		  us.deleteUser(id, rol_id, new AsyncCallback<MensajeData>() {

				@Override
				public void onFailure(Throwable caught) {					
					MessageBox.alert(constants.sistemaMarcocruzado(), constants.errorConexion(), null);					
				}

				@Override
				public void onSuccess(MensajeData data) {
					if (data.guardado) {												
						loader.load();						
					}
					 else {						 					 
						 MessageBox.alert(constants.sistemaMarcocruzado(), constants.usuarioNoEliminadoUsuario(), null);
					}						
				}
				
			});
	}
	
	public static void listRoles(){
		
		RpcProxy<List<Rol>> proxy = new RpcProxy<List<Rol>>() {  
		      @Override  
		      protected void load(Object loadConfig, AsyncCallback<List<Rol>> callback) { 
		    	  
		    	  us.getRoles(user_id,callback);	  
		      }  
		    };
		    
		    
	     loaderListView = new BaseListLoader<ListLoadResult<Rol>>(proxy, new BeanModelReader());  
	     storeListView = new ListStore<BeanModel>(loaderListView);
	     loaderListView.addLoadListener(new LoadListener() {
	    	 
	    	 public void loaderLoad(LoadEvent le) {	    		 
	    		 rolesDialog.setChecked();
	    		 rolesDialog.getButtonBar().enable();
	    	 }
	      });
	}
	
	public static void modificarRoles(List<Integer> roles_id) {		
		
		
		us.modificarRoles(user_id, roles_id, new AsyncCallback<MensajeData>() {

			@Override
			public void onFailure(Throwable caught) {				
				MessageBox.alert(constants.sistemaMarcocruzado(), constants.errorConexion(), null);				
			}

			@Override
			public void onSuccess(MensajeData data) {
				rolesDialog.status.hide();
				if (data.guardado) {					
					rolesDialog.hide();											 
					loader.load();					
				}
				 else {					 
					 rolesDialog.getButtonBar().enable();					 
					 MessageBox.alert(constants.sistemaMarcocruzado(), constants.usuarioNoGuardadoGrupo(), null);
				}						
			}
			
		});
	}
	
	public static void getComboPrivilegios(){
		RpcProxy<List<Privilegio>> proxy = new RpcProxy<List<Privilegio>>() {

			@Override
			protected void load(Object loadConfig,AsyncCallback<List<Privilegio>> callback) {				
				us.getPrivilegios(callback);
			}		      
			
	    };
	    
	    loaderPrivilegio = new BaseListLoader<ListLoadResult<ModelData>>(proxy, new BeanModelReader());
	    
	    storePrivilegio = new ListStore<BeanModel>(loaderPrivilegio);
	}
	
	public static void checkSession(){
		ls.getUsuarioSession(new AsyncCallback<Usuario>() {

			@Override
			public void onFailure(Throwable caught) {
				MessageBox.alert(constants.sistemaMarcocruzado(), constants.errorConexion(), null);				
			}

			@Override
			public void onSuccess(Usuario result) {
				if(result != null){
					//MessageBox.alert(constants.sistemaMarcocruzado(), result.getUsuario(), null);
					malou.usuario_logueado_id = result.getId();
					if(result.getIdprivilegio() == 1)
						malou.superusuario = true;
					else
						malou.superusuario = false;
					malou.dolayout();
					Utilities.tienda = result.getTienda();
					malou.addButtonExit(result.getTienda(), result.getApellidos()+", "+result.getNombres());
				}else{
					malou.loadLogin();										
				}
				
			}
		});
	}
	
	public static void isValidLogin(Usuario tda){
		ls.isValidLogin(tda, new AsyncCallback<Usuario>() {

			@Override
			public void onFailure(Throwable caught) {
				Window.alert(constants.errorConexion()+" " + caught.getMessage());						
			}

			@Override
			public void onSuccess(Usuario result) {
				if (result != null) {
					
					if(!result.getErr()){
						dialog.hide();
						malou.usuario_logueado_id = result.getId();
						if(result.getIdprivilegio() == 1)
							malou.superusuario = true;
						else
							malou.superusuario = false;
						malou.dolayout();
						Utilities.tienda = result.getTienda();
						malou.addButtonExit(result.getTienda(), result.getApellidos()+", "+result.getNombres());
						
						//ModeloPrendas.escuchar();
					}else{
						 dialog.status.hide();
						 dialog.getButtonBar().enable();				 
						 MessageBox.alert(constants.sistemaMarcocruzado(), result.getErrMsg(), null);	
					}
				}
				 else {
					 dialog.status.hide();
					 dialog.getButtonBar().enable();				 
					 MessageBox.alert(constants.sistemaMarcocruzado(), constants.loginErrorMsg(), null);				 
				}
			}
			
		});
	}
	
	public static void logout(){
		ls.logout(new AsyncCallback<Boolean>() {

			@Override
			public void onFailure(Throwable caught) {
				//Window.alert(constants.errorConexion()+" " + caught.getMessage());						
			}

			@Override
			public void onSuccess(Boolean result) {
				if(!result){
					MessageBox.alert(constants.sistemaMarcocruzado(), "No se pudo cerrar sesion", null);
				}
			}
			
		});
	}
}